home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume89 / aplictns / plplot.7 < prev    next >
Encoding:
Internet Message Format  |  1989-04-25  |  57.9 KB
  1. Path: xanth!indri!ames!oliveb!sun!rishathra!page
  2. From: page%rishathra@Sun.COM (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v89i092:  plplot - scientific plotting library, Part07/07
  5. Message-ID: <100944@sun.Eng.Sun.COM>
  6. Date: 25 Apr 89 05:47:57 GMT
  7. Sender: news@sun.Eng.Sun.COM
  8. Lines: 2206
  9. Approved: page@sun.com
  10.  
  11. Submitted-by: amr@dukee.egr.duke.edu (Tony Richardson)
  12. Posting-number: Volume 89, Issue 92
  13. Archive-name: applications/plplot.7
  14.  
  15. # This is a shell archive.
  16. # Remove anything above and including the cut line.
  17. # Then run the rest of the file through 'sh'.
  18. # Unpacked files will be owned by you and have default permissions.
  19. #----cut here-----cut here-----cut here-----cut here----#
  20. #!/bin/sh
  21. # shar: SHell ARchive
  22. # Run the following text through 'sh' to create:
  23. #    plot3d.c
  24. #    plplot.h
  25. #    plpoi1.c
  26. #    plpoin.c
  27. #    plptex.c
  28. #    plr135.c
  29. #    plr45.c
  30. #    plschr.c
  31. #    plside3.c
  32. #    plsmaj.c
  33. #    plsmin.c
  34. #    plssym.c
  35. #    plstar.c
  36. #    plstik.c
  37. #    plstr.c
  38. #    plstrl.c
  39. #    plstyl.c
  40. #    plsvpa.c
  41. #    plsym.c
  42. #    plsym1.c
  43. #    plt3zz.c
  44. #    pltext.c
  45. #    plvpor.c
  46. #    plvsta.c
  47. #    plw3d.c
  48. #    plwind.c
  49. #    plxtik.c
  50. #    plxybx.c
  51. #    plxytx.c
  52. #    plytik.c
  53. #    plzbx.c
  54. #    plztx.c
  55. #    round.c
  56. #    scratch
  57. #    setphy.c
  58. #    setpxl.c
  59. #    setsub.c
  60. #    stindex.c
  61. #    strpos.c
  62. #    tektronix.c
  63. #    xform.c
  64. # This is archive 7 of a 7-part kit.
  65. # This archive created: Thu Apr 20 13:47:08 1989
  66. echo "extracting plot3d.c"
  67. sed 's/^X//' << \SHAR_EOF > plot3d.c
  68. X/* Plots a 3-d representation of the function z[x][y]. The x values */
  69. X/* are stored as x[0..nx-1], the y values as y[0..ny-1], and the */
  70. X/* z values are in the 2-d array z[][0..ly-1]. The integer "opt" */
  71. X/* specifies: */
  72. X/*  opt = 1:  Draw lines parallel to x-axis */
  73. X/*  opt = 2:  Draw lines parallel to y-axis */
  74. X/*  opt = 3:  Draw lines parallel to both axes */
  75. X
  76. X/* "work" is an integer work array of size at least 4*max(nx,ny) */
  77. X
  78. X#include "plplot.h"
  79. X#include <math.h>
  80. X
  81. Xvoid plot3d(x,y,z,work,ly,nx,ny,opt)
  82. Xint ly, nx, ny, opt;
  83. Xfloat x[],y[],*z;
  84. Xint work[];
  85. X{
  86. X      int b;
  87. X      float cxx, cxy, cyx, cyy, cyz;
  88. X
  89. X      int init;
  90. X      int i, ix, iy;
  91. X
  92. X      int level;
  93. X      glev(&level);
  94. X      if (level < 3) fatal("Please set up window before calling PLOT3D");
  95. X 
  96. X      if (opt<1 || opt>3) fatal("Bad option in PLOT3D");
  97. X      if (nx<=0 || ny<=0 || ly<ny) fatal("Bad array dimensions in PLOT3D.");
  98. X
  99. X/* Check that points in x and in y are strictly increasing */
  100. X
  101. X      for (i=0; i<nx-1; i++)
  102. X        if (x[i]>=x[i+1]) fatal("X(*) must be strictly increasing in PLOT3D");
  103. X
  104. X      for (i=0; i<ny-1; i++)
  105. X        if (y[i]>=y[i+1]) fatal("Y(*) must be strictly increasing in PLOT3D");
  106. X
  107. X      b = 2*max(nx,ny)+1;
  108. X      gw3wc(&cxx,&cxy,&cyx,&cyy,&cyz);
  109. X      init = 1;
  110. X      
  111. X      if (cxx >= 0.0 && cxy <= 0.0) {
  112. X        if (opt != 2) {
  113. X          for (iy=2; iy<=ny; iy++)  {
  114. X            plt3zz(1,iy,1,-1,-opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  115. X            init = 0;
  116. X          }
  117. X        }
  118. X        else  {
  119. X          plt3zz(1,ny,1,-1,-opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  120. X          init = 0;
  121. X        }
  122. X        if (opt != 1) 
  123. X          for (ix=1; ix<=nx-1; ix++)
  124. X            plt3zz(ix,ny,1,-1,opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  125. X        else
  126. X          plt3zz(1,ny,1,-1,opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  127. X      }
  128. X      else if (cxx <= 0.0 && cxy <= 0.0) {
  129. X        if (opt != 1) {
  130. X          for (ix=2; ix<=nx; ix++) {
  131. X            plt3zz(ix,ny,-1,-1,opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  132. X            init = 0;
  133. X          }
  134. X        }
  135. X        else  {
  136. X          plt3zz(nx,ny,-1,-1,opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  137. X          init = 0;
  138. X        }
  139. X        if (opt != 2) 
  140. X          for (iy=ny; iy>=2; iy--)
  141. X            plt3zz(nx,iy,-1,-1,-opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  142. X        else
  143. X          plt3zz(nx,ny,-1,-1,-opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  144. X      }
  145. X      else if (cxx <= 0.0 && cxy >= 0.0) {
  146. X        if (opt != 2) {
  147. X          for (iy=ny-1; iy>=1; iy--) {
  148. X            plt3zz(nx,iy,-1,1,-opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  149. X            init = 0;
  150. X          }
  151. X        }
  152. X        else {
  153. X          plt3zz(nx,1,-1,1,-opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  154. X          init = 0;
  155. X        }
  156. X        if (opt != 1)
  157. X          for (ix=nx; ix>=2; ix--)
  158. X            plt3zz(ix,1,-1,1,opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  159. X        else
  160. X          plt3zz(nx,1,-1,1,opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  161. X      }
  162. X      else if (cxx >= 0.0 && cxy >= 0.0) {
  163. X        if (opt != 1) {
  164. X          for (ix=nx-1; ix>=1; ix--) {
  165. X            plt3zz(ix,1,1,1,opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  166. X            init = 0;
  167. X          }
  168. X        }
  169. X        else  {
  170. X          plt3zz(1,1,1,1,opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  171. X          init = 0;
  172. X        }
  173. X        if (opt != 2)
  174. X          for (iy=1; iy<=ny-1; iy++)
  175. X            plt3zz(1,iy,1,1,-opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  176. X        else
  177. X          plt3zz(1,1,1,1,-opt,init,x,y,z,ly,nx,ny,&work[0],&work[b-1]);
  178. X      }      
  179. X}
  180. SHAR_EOF
  181. echo "extracting plplot.h"
  182. sed 's/^X//' << \SHAR_EOF > plplot.h
  183. X/* This file contains all of the type declarations for the functions *
  184. X * in the plplot library.  This file should be included in all user  *
  185. X * routines that make use of that library.                           */
  186. X
  187. X/* All of the void type declarations are made first. */
  188. Xvoid pladv();
  189. Xvoid plbeg();
  190. Xvoid plbin();
  191. Xvoid plbox();
  192. Xvoid plccal();
  193. Xvoid plclr();
  194. Xvoid plcntr();
  195. Xvoid plcol();
  196. Xvoid plcont();
  197. Xvoid pldeco();
  198. Xvoid pldtik();
  199. Xvoid plend();
  200. Xvoid plenv();
  201. Xvoid plerrx();
  202. Xvoid plerry();
  203. Xvoid plerx1();
  204. Xvoid plery1();
  205. Xvoid plfont();
  206. Xvoid plform();
  207. Xvoid plgra();
  208. Xvoid plgspa();
  209. Xvoid plhist();
  210. Xvoid plhrsh();
  211. Xvoid pljoin();
  212. Xvoid pllab();
  213. Xvoid pllclp();
  214. Xvoid plline();
  215. Xvoid plmtex();
  216. Xvoid plnxtv();
  217. Xvoid plpoi1();
  218. Xvoid plpoin();
  219. Xvoid plptex();
  220. Xvoid plr135();
  221. Xvoid plr45();
  222. Xvoid plschr();
  223. Xvoid plsmaj();
  224. Xvoid plsmin();
  225. Xvoid plssym();
  226. Xvoid plstar();
  227. Xvoid plstik();
  228. Xvoid plstr();
  229. Xvoid plstyl();
  230. Xvoid plsvpa();
  231. Xvoid plsym();
  232. Xvoid plsym1();
  233. Xvoid pltext();
  234. Xvoid plupd();
  235. Xvoid plvpor();
  236. Xvoid plvsta();
  237. Xvoid plwind();
  238. Xvoid plxtik();
  239. Xvoid plxybx();
  240. Xvoid plxytx();
  241. Xvoid plytik();
  242. Xvoid plzbx();
  243. Xvoid plztx();
  244. X
  245. X/* 3-D routine types*/
  246. Xvoid pl3cut();
  247. Xvoid plbox3();
  248. Xvoid plgrid3();
  249. Xvoid plot3d();
  250. Xvoid plside3();
  251. Xvoid plt3zz();
  252. Xvoid plw3d();
  253. X
  254. X/* The novice plplot user will not need to call the following functions */
  255. Xvoid fatal();
  256. Xvoid genlin();
  257. Xvoid movphy();
  258. Xvoid draphy();
  259. Xvoid movwor();
  260. Xvoid drawor();
  261. Xvoid setphy();
  262. Xvoid setpxl();
  263. Xvoid setsub();
  264. Xvoid xform();
  265. Xvoid glev();
  266. Xvoid slev();
  267. Xvoid gbase();
  268. Xvoid sbase();
  269. Xvoid gnms();
  270. Xvoid snms();
  271. Xvoid gdev();
  272. Xvoid sdev();
  273. Xvoid gcurr();
  274. Xvoid scurr();
  275. Xvoid gdom();
  276. Xvoid sdom();
  277. Xvoid grange();
  278. Xvoid srange();
  279. Xvoid gw3wc();
  280. Xvoid sw3wc();
  281. Xvoid gvpp();
  282. Xvoid svpp();
  283. Xvoid gspp();
  284. Xvoid sspp();
  285. Xvoid gclp();
  286. Xvoid sclp();
  287. Xvoid gphy();
  288. Xvoid sphy();
  289. Xvoid gsub();
  290. Xvoid ssub();
  291. Xvoid gumpix();
  292. Xvoid sumpix();
  293. Xvoid gatt();
  294. Xvoid satt();
  295. Xvoid gspd();
  296. Xvoid sspd();
  297. Xvoid gvpd();
  298. Xvoid svpd();
  299. Xvoid gvpw();
  300. Xvoid svpw();
  301. Xvoid gpixmm();
  302. Xvoid spixmm();
  303. Xvoid gwp();
  304. Xvoid swm();
  305. Xvoid gwm();
  306. Xvoid swp();
  307. Xvoid gdp();
  308. Xvoid sdp();
  309. Xvoid gmp();
  310. Xvoid smp();
  311. Xvoid gchr();
  312. Xvoid schr();
  313. Xvoid gsym();
  314. Xvoid ssym();
  315. Xvoid gmaj();
  316. Xvoid smaj();
  317. Xvoid gmin();
  318. Xvoid smin();
  319. X
  320. X/* Functions that return floats */
  321. Xfloat plstrl();
  322. Xfloat dcmmx();
  323. Xfloat dcmmy();
  324. Xfloat dcscx();
  325. Xfloat dcscy();
  326. Xfloat mmdcx();
  327. Xfloat mmdcy();
  328. Xfloat scdcx();
  329. Xfloat scdcy();
  330. Xfloat wcmmx();
  331. Xfloat wcmmy();
  332. Xfloat w3wcx();
  333. Xfloat w3wcy();
  334. X
  335. X/* Functions returning ints */
  336. Xint plabv();
  337. Xint plcvec();
  338. Xint dcpcx();
  339. Xint dcpcy();
  340. Xint mmpcx();
  341. Xint mmpcy();
  342. Xint round();
  343. Xint stindex();
  344. Xint strpos();
  345. Xint wcpcx();
  346. Xint wcpcy();
  347. X
  348. X/* Device independent routines */
  349. Xvoid grbeg();
  350. Xvoid grclr();
  351. Xvoid grcol();
  352. Xvoid grinit();
  353. Xvoid grgra();
  354. Xvoid grline();
  355. Xvoid grtext();
  356. Xvoid grtidy();
  357. X
  358. X/* Declarations for any new device drivers should be added to the list *
  359. X * below.  These routines are called only in the file plstar.c (except *
  360. X * for beepw() which is also called by ???) */
  361. Xvoid amiini();
  362. Xvoid amitex();
  363. Xvoid amigra();
  364. Xvoid amicol();
  365. Xvoid amiclr();
  366. Xvoid amilin();
  367. Xvoid amitid();
  368. Xvoid beepw();
  369. X
  370. Xvoid tekini();
  371. Xvoid tektex();
  372. Xvoid tekgra();
  373. Xvoid tekclr();
  374. Xvoid tekcol();
  375. Xvoid teklin();
  376. Xvoid tektid();
  377. X
  378. Xvoid impini();
  379. Xvoid imptex();
  380. Xvoid impgra();
  381. Xvoid impclr();
  382. Xvoid impcol();
  383. Xvoid implin();
  384. Xvoid imptid();
  385. X
  386. Xvoid jetini();
  387. Xvoid jettex();
  388. Xvoid jetgra();
  389. Xvoid jetclr();
  390. Xvoid jetcol();
  391. Xvoid jetlin();
  392. Xvoid jettid();
  393. SHAR_EOF
  394. echo "extracting plpoi1.c"
  395. sed 's/^X//' << \SHAR_EOF > plpoi1.c
  396. X#include "plplot.h"
  397. X
  398. Xextern short int *hersh[];
  399. X
  400. Xvoid plpoi1(x,y,code)
  401. Xfloat x,y;
  402. Xint code;
  403. X{
  404. X      int sym, font, col;
  405. X
  406. X/* Initialize parameters. */
  407. X
  408. X      gatt(&font,&col);
  409. X      sym = *(hersh[font-1]+code);
  410. X      plhrsh(sym,wcpcx(x),wcpcy(y));
  411. X}
  412. SHAR_EOF
  413. echo "extracting plpoin.c"
  414. sed 's/^X//' << \SHAR_EOF > plpoin.c
  415. X/* Plots single precision array y against x for n points using */
  416. X/* ASCII code "code" */
  417. X
  418. X#include "plplot.h"
  419. X
  420. Xvoid plpoin(n,x,y,code)
  421. Xint n, code;
  422. Xfloat x[],y[];
  423. X{
  424. X      int i;
  425. X
  426. X      int level;
  427. X      glev(&level);
  428. X      if (level < 3) fatal("Please set up window before calling PLPOIN.");
  429. X      if (code < 0 || code > 127) fatal("Invalid code in PLPOIN.");
  430. X
  431. X      for(i=0; i<n; i++)
  432. X        plpoi1(x[i],y[i],code);
  433. X}
  434. SHAR_EOF
  435. echo "extracting plptex.c"
  436. sed 's/^X//' << \SHAR_EOF > plptex.c
  437. X/* Prints out "text" at world cooordinate (x,y). The text may be       */
  438. X/* at any angle "angle" relative to the horizontal. The parameter      */
  439. X/* "just" adjusts the horizontal justification of the string:          */
  440. X/*   just = 0.0 => left hand edge of string is at (x,y)                */
  441. X/*   just = 1.0 => right hand edge of string is at (x,y)               */
  442. X/*   just = 0.5 => centre of string is at (x,y) etc.                   */
  443. X/* N.B. Centreline of the string passes through (x,y)                  */
  444. X
  445. X#include "plplot.h"
  446. X#include <math.h>
  447. X
  448. Xvoid plptex(x,y,dx,dy,just,text)
  449. Xfloat x,y,dx,dy,just;
  450. Xchar *text;
  451. X{      
  452. X      int refx, refy;
  453. X      float shift, cc, ss;
  454. X      float xform[4],diag;
  455. X      float xscl, xoff, yscl, yoff;
  456. X   
  457. X      int level;
  458. X      glev(&level);
  459. X      if (level < 3) fatal("Please set up window before calling PLPTEX.");
  460. X
  461. X      gwm(&xscl,&xoff,&yscl,&yoff);
  462. X      cc = xscl * dx;
  463. X      ss = yscl * dy;
  464. X      diag = sqrt(cc*cc + ss*ss);
  465. X      cc = cc/diag;
  466. X      ss = ss/diag;
  467. X      
  468. X      gmp(&xscl,&xoff,&yscl,&yoff);
  469. X      shift = 0.0;
  470. X      
  471. X      xform[0] = cc;
  472. X      xform[1] = -ss;
  473. X      xform[2] = ss;
  474. X      xform[3] = cc;
  475. X
  476. X      if (just != 0.0) shift = plstrl(text) * just;
  477. X      refx = wcpcx(x) - shift * cc * xscl;
  478. X      refy = wcpcy(y) - shift * ss * yscl;
  479. X      plstr(0,xform,refx,refy,text);
  480. X}
  481. SHAR_EOF
  482. echo "extracting plr135.c"
  483. sed 's/^X//' << \SHAR_EOF > plr135.c
  484. X#include "plplot.h"
  485. X
  486. Xvoid plr135(ix,iy,isens)
  487. Xint *ix, *iy, isens;
  488. X{
  489. X      *ix = -*ix;
  490. X      *iy = -*iy;
  491. X      plr45(ix,iy,isens);
  492. X}
  493. SHAR_EOF
  494. echo "extracting plr45.c"
  495. sed 's/^X//' << \SHAR_EOF > plr45.c
  496. X#include "plplot.h"
  497. X#include <math.h>
  498. X
  499. Xvoid plr45(ix,iy,isens)
  500. Xint *ix, *iy, isens;
  501. X{
  502. X      int ixx, iyy;
  503. X
  504. X      ixx = *ix-isens*(*iy);
  505. X      iyy = *ix * isens + *iy;
  506. X      *ix = ixx/max(1,abs(ixx));
  507. X      *iy = iyy/max(1,abs(iyy));
  508. X}
  509. SHAR_EOF
  510. echo "extracting plschr.c"
  511. sed 's/^X//' << \SHAR_EOF > plschr.c
  512. X#include "plplot.h"
  513. X
  514. Xvoid plschr(def,scale)
  515. Xfloat def,scale;
  516. X{
  517. X    float defalt, ht;
  518. X
  519. X    if (def != 0.0) 
  520. X       schr(def,scale*def);
  521. X    else {
  522. X       gchr(&defalt,&ht);
  523. X       schr(defalt,scale*defalt);
  524. X    }
  525. X}
  526. SHAR_EOF
  527. echo "extracting plside3.c"
  528. sed 's/^X//' << \SHAR_EOF > plside3.c
  529. X/* This routine draws sides around the front of the 3d plot so that */
  530. X/* it does not appear to float */
  531. X
  532. X#include "plplot.h"
  533. X
  534. Xvoid plside3(x,y,z,nx,ny,ly,opt)
  535. Xint nx, ny, ly, opt;
  536. Xfloat *x, *y, *z;
  537. X{
  538. X    int i;
  539. X    float cxx, cxy, cyx, cyy, cyz;
  540. X    float xmin, ymin, zmin, xmax, ymax, zmax, zscale;
  541. X    float tx, ty, ux, uy;
  542. X
  543. X    gw3wc(&cxx,&cxy,&cyx,&cyy,&cyz);
  544. X    gdom(&xmin,&xmax,&ymin,&ymax);
  545. X    grange(&zscale,&zmin,&zmax);
  546. X
  547. X    if (cxx >= 0.0 && cxy <= 0.0)  {
  548. X        /* Get x, y coordinates of legs and plot */
  549. X        if (opt != 1) {
  550. X            for (i=0; i<nx; i++)  {
  551. X                tx = w3wcx(*(x+i),*y,zmin);
  552. X                ty = w3wcy(*(x+i),*y,zmin);
  553. X                ux = w3wcx(*(x+i),*y,*(z+i*ly));
  554. X                uy = w3wcy(*(x+i),*y,*(z+i*ly));
  555. X                pljoin(tx,ty,ux,uy);
  556. X            }
  557. X        }
  558. X
  559. X        if (opt != 2) {
  560. X            for (i=0; i<ny; i++)  {
  561. X                tx = w3wcx(*x,*(y+i),zmin);
  562. X                ty = w3wcy(*x,*(y+i),zmin);
  563. X                ux = w3wcx(*x,*(y+i),*(z+i));
  564. X                uy = w3wcy(*x,*(y+i),*(z+i));
  565. X                pljoin(tx,ty,ux,uy);
  566. X            }
  567. X        }
  568. X    }
  569. X    else if(cxx <= 0.0  && cxy <= 0.0)  {
  570. X        if (opt != 1 )  {
  571. X            for (i=0; i<nx; i++)  {
  572. X                tx = w3wcx(*(x+i),*(y+ny-1),zmin);
  573. X                ty = w3wcy(*(x+i),*(y+ny-1),zmin);
  574. X                ux = w3wcx(*(x+i),*(y+ny-1),*(z+i*ly+ny-1));
  575. X                uy = w3wcy(*(x+i),*(y+ny-1),*(z+i*ly+ny-1));
  576. X                pljoin(tx,ty,ux,uy);
  577. X            }
  578. X        }
  579. X
  580. X        if (opt != 2)  {
  581. X            for (i=0; i<ny; i++)  {
  582. X                tx = w3wcx(*x,*(y+i),zmin);
  583. X                ty = w3wcy(*x,*(y+i),zmin);
  584. X                ux = w3wcx(*x,*(y+i),*(z+i));
  585. X                uy = w3wcy(*x,*(y+i),*(z+i));
  586. X                pljoin(tx,ty,ux,uy);
  587. X            }
  588. X        }
  589. X    }
  590. X    else if(cxx <= 0.0  && cxy >= 0.0)  {
  591. X        if (opt != 1)  {
  592. X            for (i=0; i<nx; i++)  {
  593. X                tx = w3wcx(*(x+i),*(y+ny-1),zmin);
  594. X                ty = w3wcy(*(x+i),*(y+ny-1),zmin);
  595. X                ux = w3wcx(*(x+i),*(y+ny-1),*(z+i*ly+ny-1));
  596. X                uy = w3wcy(*(x+i),*(y+ny-1),*(z+i*ly+ny-1));
  597. X                pljoin(tx,ty,ux,uy);
  598. X            }
  599. X        }
  600. X
  601. X        if (opt != 2)  {
  602. X            for (i=0; i<ny; i++)  {
  603. X                tx = w3wcx(*(x+nx-1),*(y+i),zmin);
  604. X                ty = w3wcy(*(x+nx-1),*(y+i),zmin);
  605. X                ux = w3wcx(*(x+nx-1),*(y+i),*(z+(nx-1)*ly+i));
  606. X                uy = w3wcy(*(x+nx-1),*(y+i),*(z+(nx-1)*ly+i));
  607. X                pljoin(tx,ty,ux,uy);
  608. X            }
  609. X        }
  610. X    }
  611. X    else if(cxx >= 0.0  && cxy >= 0.0)  {
  612. X        if (opt != 1)  {
  613. X            for (i=0; i<nx; i++)  {
  614. X                tx = w3wcx(*(x+i),*y,zmin);
  615. X                ty = w3wcy(*(x+i),*y,zmin);
  616. X                ux = w3wcx(*(x+i),*y,*(z+i*ly));
  617. X                uy = w3wcy(*(x+i),*y,*(z+i*ly));
  618. X                pljoin(tx,ty,ux,uy);
  619. X            }
  620. X        }
  621. X
  622. X        if (opt != 2)  {
  623. X            for (i=0; i<ny; i++)  {
  624. X                tx = w3wcx(*(x+nx-1),*(y+i),zmin);
  625. X                ty = w3wcy(*(x+nx-1),*(y+i),zmin);
  626. X                ux = w3wcx(*(x+nx-1),*(y+i),*(z+(nx-1)*ly+i));
  627. X                uy = w3wcy(*(x+nx-1),*(y+i),*(z+(nx-1)*ly+i));
  628. X                pljoin(tx,ty,ux,uy);
  629. X            }
  630. X        }
  631. X    }
  632. X}
  633. SHAR_EOF
  634. echo "extracting plsmaj.c"
  635. sed 's/^X//' << \SHAR_EOF > plsmaj.c
  636. X#include "plplot.h"
  637. X
  638. Xvoid plsmaj(def,scale)
  639. Xfloat def,scale;
  640. X{
  641. X    float defalt, ht;
  642. X
  643. X    if (def != 0.0)
  644. X       smaj(def,scale*def);
  645. X    else {
  646. X       gmaj(&defalt,&ht);
  647. X       smaj(defalt,scale*defalt);
  648. X    }
  649. X}
  650. SHAR_EOF
  651. echo "extracting plsmin.c"
  652. sed 's/^X//' << \SHAR_EOF > plsmin.c
  653. X#include "plplot.h"
  654. X
  655. Xvoid plsmin(def,scale)
  656. Xfloat def, scale;
  657. X{
  658. X    float defalt, ht;
  659. X    if (def !=  0.0) 
  660. X       smin(def,scale*def);
  661. X    else {
  662. X       gmin(&defalt,&ht);
  663. X       smin(defalt,scale*defalt);
  664. X    }
  665. X}
  666. SHAR_EOF
  667. echo "extracting plssym.c"
  668. sed 's/^X//' << \SHAR_EOF > plssym.c
  669. X#include "plplot.h"
  670. X
  671. Xvoid plssym(def,scale)
  672. Xfloat def,scale;
  673. X{
  674. X    float defalt,ht;
  675. X
  676. X    if (def != 0.0) 
  677. X       ssym(def,scale*def);
  678. X    else {
  679. X       gsym(&defalt,&ht);
  680. X       ssym(defalt,scale*defalt);
  681. X    }
  682. X}
  683. SHAR_EOF
  684. echo "extracting plstar.c"
  685. sed 's/^X//' << \SHAR_EOF > plstar.c
  686. X#include "plplot.h"
  687. X#include "declare.h"
  688. X#include <stdio.h>
  689. X
  690. X/* Asks for number of plotting device, and call plbeg to divide the */
  691. X/* page into nx by ny subpages */
  692. X
  693. Xstatic int mk=0, sp=0;
  694. X
  695. Xvoid plstar(nx,ny)
  696. Xint nx, ny;
  697. X{
  698. X   int dev,lev;
  699. X
  700. X   glev(&lev);
  701. X   if (lev != 0) plend();
  702. X      
  703. X   printf("\nPlotting Options:");
  704. X   printf("\n < 1> Amiga");
  705. X   printf("\n < 2> LaserJet II file    (landscape)");
  706. X   printf("\n < 3> LaserJet II file    (portrait)");
  707. X   printf("\n < 4> imPRESS     file    (landscape)");
  708. X   printf("\n < 5> imPRESS     file    (portrait)");
  709. X   printf("\n < 6> Tektronix   file    (landscape)");
  710. X   printf("\n < 7> Tektronix   file    (portrait)");
  711. X   printf("\n");
  712. X   printf("\nEnter device number: ");
  713. X   scanf("%d",&dev);
  714. X   while(getchar() != '\n') /* Read all of line including new line char */
  715. X       ;
  716. X   plbeg(dev,nx,ny);
  717. X}
  718. X
  719. X/* Initializes the graphics device "dev"  */
  720. Xvoid grbeg(dev)
  721. Xint dev;
  722. X{
  723. X   int termin, phyxmi, phyxma, phyymi, phyyma;
  724. X   void grinit(), grclr(), grcol(), grgra();
  725. X
  726. X   /* Set up device specific stuff */
  727. X
  728. X   /* Use setpxl to set the device dots per mm in the x and y directions */
  729. X   /* dpmmx = dots/mm in x direction (float) */
  730. X   /* dpmmy = dots/mm in y direction (float) */
  731. X   /* setpxl(dpmmx,dpmmy); */
  732. X
  733. X   /* PLPLOT assumes that the plot origin is in the lower left corner */
  734. X   /* with y increasing upward and x increasing to the right */
  735. X   /* Use setphy to specify how PLPLOT should translate plotting coords */
  736. X   /* to device coords */
  737. X   /* xmindev = minimum x device coordinate (int) */
  738. X   /* xmaxdev = maximum x device coordinate (int) */
  739. X   /* ymindev = minimum y device coordinate (int) */
  740. X   /* ymaxdev = maximum y device coordinate (int) */
  741. X   /* setphy(xmindev,xmaxdev,ymindev,ymaxdev); */
  742. X
  743. X   if (dev == 1) {
  744. X     setpxl(2.52,2.25);
  745. X     setphy(0,639,0,399);
  746. X     termin = 1;
  747. X   }
  748. X   else if (dev == 2) {
  749. X       setpxl(5.905,5.905);  /* 150 dpi mode */
  750. X       termin = 0;
  751. X       setphy(0,1409,0,1103);
  752. X   }
  753. X   else if (dev == 3) {
  754. X       setpxl(5.905,5.905);  /* 150 dpi mode */
  755. X       termin = 0;
  756. X       setphy(0,1103,1409,0);
  757. X   }
  758. X   else if (dev == 4) {
  759. X       setpxl(11.81,11.81);  /* 300 dpi */
  760. X       termin = 0;
  761. X       setphy(0,2999,0,2249);
  762. X   }
  763. X   else if (dev == 5) {
  764. X       setpxl(11.81,11.81);  /* 300 dpi */
  765. X       termin = 0;
  766. X       setphy(2249,0,0,2999);
  767. X   }
  768. X   else if (dev == 6 )  {
  769. X       setpxl(4.771,4.653);
  770. X       termin = 0;
  771. X       setphy(0,1023,0,779);
  772. X   }
  773. X   else if (dev == 7)  {
  774. X       setpxl(4.653,4.771);
  775. X       termin = 0;
  776. X       setphy(779,0,0,1023);
  777. X   }
  778. X   else {
  779. X     printf("\nUnknown output device\n");
  780. X     exit(1);
  781. X   }
  782. X
  783. X   sdev(dev,termin,0);
  784. X   grinit();
  785. X
  786. X   /* Set default sizes, fonts, and colors */
  787. X   plschr(4.0,1.0);
  788. X   plssym(4.0,1.0);
  789. X   plsmaj(3.0,1.0);
  790. X   plsmin(1.5,1.0);
  791. X   satt(1,1);
  792. X
  793. X   /* Switch to graphics mode and clear screen */
  794. X   grgra();
  795. X   grclr();
  796. X   grcol();
  797. X   plstyl(0,&mk,&sp);
  798. X      
  799. X   gphy(&phyxmi,&phyxma,&phyymi,&phyyma);
  800. X   sclp(phyxmi,phyxma,phyymi,phyyma);
  801. X}
  802. X
  803. X/* Clears the graphics screen */
  804. Xvoid grclr()
  805. X{
  806. X      if (device == 1)
  807. X        amiclr();
  808. X      else if (device == 2 || device == 3)
  809. X        jetclr();
  810. X      else if (device == 4 || device == 5)
  811. X        impclr();
  812. X      else if (device == 6 || device == 7)
  813. X        tekclr();
  814. X}
  815. X
  816. X/* Sets up the line colour to value in global variable "colour" */
  817. Xvoid grcol()
  818. X{
  819. X      if (device == 1)
  820. X        amicol(colour);
  821. X}
  822. X
  823. X/* Initializes the graphics device */
  824. Xvoid grinit()
  825. X{
  826. X      if (device == 1)
  827. X        amiini();
  828. X      else if (device == 2 || device == 3)
  829. X        jetini();
  830. X      else if (device == 4 || device == 5)
  831. X        impini();
  832. X      else if (device == 6 || device == 7)
  833. X        tekini();
  834. X}
  835. X
  836. X/* Switches to graphics mode */
  837. Xvoid grgra()
  838. X{
  839. X      if (device == 1)
  840. X        amigra();
  841. X      else if (device == 2 || device == 3)
  842. X        jetgra();
  843. X      else if (device == 4 || device == 5)
  844. X        impgra();
  845. X      else if (device == 6 || device == 7)
  846. X        tekgra();
  847. X
  848. X      graphx = 1;
  849. X}
  850. X
  851. X/* Draws a line from (x1,x2) to (x2,y2), used by genlin() */
  852. X/* Notice how x and y are swapped to switch from the default */
  853. X/* orientation */
  854. Xvoid grline(x1,y1,x2,y2)
  855. Xint x1,y1,x2,y2;
  856. X{
  857. X      if (device == 1)
  858. X        amilin(x1,y1,x2,y2);
  859. X      else if (device == 2)
  860. X        jetlin(y1,x1,y2,x2);
  861. X      else if (device == 3)
  862. X        jetlin(x1,y1,x2,y2);
  863. X      else if (device == 4)
  864. X        implin(x1,y1,x2,y2);
  865. X      else if (device == 5)
  866. X        implin(y1,x1,y2,x2);
  867. X      else if (device == 6)
  868. X        teklin(x1,y1,x2,y2);
  869. X      else if (device == 7)
  870. X        teklin(y1,x1,y2,x2);
  871. X}
  872. X
  873. X/* Switches to text mode */
  874. Xvoid grtext()
  875. X{
  876. X      if (device == 1)
  877. X        amitex();
  878. X      else if (device == 2 || device == 3)
  879. X        jettex();
  880. X      else if (device == 4 || device == 5)
  881. X        imptex();
  882. X      else if (device == 6 || device == 7)
  883. X        tektex();
  884. X
  885. X      graphx = 0;
  886. X}
  887. X
  888. X/* Called by plend to tidy up graphics device */
  889. Xvoid grtidy()
  890. X{
  891. X      if (device == 1)
  892. X        amitid();
  893. X      else if (device == 2 || device == 3)
  894. X        jettid();
  895. X      else if (device == 4 || device == 5)
  896. X        imptid();
  897. X      else if (device == 6 || device == 7)
  898. X        tektid();
  899. X}
  900. SHAR_EOF
  901. echo "extracting plstik.c"
  902. sed 's/^X//' << \SHAR_EOF > plstik.c
  903. X/* Draws a slanting tick at position (mx,my) (measured in mm) of */
  904. X/* vector length (dx,dy) */
  905. X
  906. X#include "plplot.h"
  907. X
  908. Xvoid plstik(mx,my,dx,dy)
  909. Xfloat mx, my, dx, dy;
  910. X{
  911. X      draphy(mmpcx(mx),mmpcy(my));
  912. X      draphy(mmpcx(mx+dx),mmpcy(my+dy));
  913. X      draphy(mmpcx(mx),mmpcy(my));
  914. X}
  915. SHAR_EOF
  916. echo "extracting plstr.c"
  917. sed 's/^X//' << \SHAR_EOF > plstr.c
  918. X/* Prints out a "string" at reference position with physical         */
  919. X/* coordinates (refx,refy). The coordinates of the vectors defining  */
  920. X/* the string are passed through the linear mapping defined by the   */
  921. X/* 2 x 2 matrix xform() before being plotted.                        */
  922. X/* The reference position is at the left-hand edge of the string. If */
  923. X/* base = 1, it is aligned with the baseline of the string. If       */
  924. X/* base = 0, it is aligned with the centre of the character box.     */
  925. X
  926. X/* Note, all calculations are done in terms of millimetres. These */
  927. X/* are scaled as necessary before plotting the string on the page */
  928. X
  929. X#include "plplot.h"
  930. X#include <math.h>
  931. X
  932. Xvoid plstr(base,xform,refx,refy,string)
  933. Xint base, refx, refy;
  934. Xchar *string;
  935. Xfloat xform[4];
  936. X{
  937. X      int symbol[256];
  938. X      short int xygrid[300];
  939. X      int ch, cx, cy, i, k, length, level, penup;
  940. X      int xbase, ybase, ydisp, lx, ly, style;
  941. X      int oline, uline;
  942. X      float width, xorg, yorg, x, y, def, ht, dscale, scale;
  943. X      float xscl, xoff, yscl, yoff;
  944. X   
  945. X      width = 0.0;
  946. X      oline = 0;
  947. X      uline = 0;
  948. X
  949. X      gchr(&def,&ht);
  950. X      dscale = 0.05*ht;
  951. X      scale = dscale;
  952. X      gmp(&xscl,&xoff,&yscl,&yoff);
  953. X
  954. X/* Line style must be continuous */
  955. X
  956. X      gnms(&style);
  957. X      snms(0);
  958. X      
  959. X      pldeco(symbol,&length,string);
  960. X      xorg = 0.0;
  961. X      yorg = 0.0;
  962. X      level = 0;
  963. X 
  964. X      for (i=0; i<length; i++)  {
  965. X        ch = symbol[i];
  966. X        if (ch == -1) {
  967. X          level = level + 1;
  968. X          yorg = yorg + 16.0 * scale;
  969. X          scale = dscale * pow(0.75,(double)abs(level));
  970. X        }
  971. X        else if (ch == -2) {  
  972. X          level = level - 1;
  973. X          scale = dscale * pow(0.75,(double)abs(level));
  974. X          yorg = yorg - 16.0 * scale;
  975. X        }
  976. X        else if (ch == -3)
  977. X          xorg = xorg - width * scale;
  978. X        else if (ch == -4)
  979. X          oline = !oline;
  980. X        else if (ch == -5) 
  981. X          uline = !uline;
  982. X        else  {
  983. X          if (plcvec(ch,xygrid)) {
  984. X            xbase = xygrid[3];
  985. X            width = xygrid[4] - xbase;
  986. X            if (base == 0) {
  987. X              ybase = 0;
  988. X              ydisp = xygrid[1];
  989. X            }
  990. X            else  {
  991. X              ybase = xygrid[1];
  992. X              ydisp = 0;
  993. X            }
  994. X            k = 5;
  995. X            penup = 1;
  996. Xlab2:
  997. X              cx = xygrid[k];
  998. X              k = k+1;
  999. X              cy = xygrid[k];
  1000. X              k = k+1;
  1001. X              if (cx == -64 && cy == -64) goto lab3;
  1002. X              if (cx == -64 && cy == 0) 
  1003. X                penup = 1;
  1004. X              else {
  1005. X                x = xorg + (cx - xbase) * scale;
  1006. X                y = yorg + (cy - ybase) * scale;
  1007. X                lx = refx + round(xscl*(xform[0]*x + xform[1]*y));
  1008. X                ly = refy + round(yscl*(xform[2]*x + xform[3]*y));
  1009. X                if (penup != 0) {
  1010. X                  movphy(lx,ly);
  1011. X                  penup = 0;
  1012. X                }
  1013. X                else
  1014. X                  draphy(lx,ly);
  1015. X              }
  1016. X            goto lab2;
  1017. Xlab3:
  1018. X            if (oline) {
  1019. X              x = xorg;
  1020. X              y = yorg + (30+ydisp)*scale;
  1021. X              lx = refx + round(xscl*(xform[0]*x + xform[1]*y));
  1022. X              ly = refy + round(yscl*(xform[2]*x + xform[3]*y));
  1023. X              movphy(lx,ly);
  1024. X              x = xorg + width*scale;
  1025. X              lx = refx + round(xscl*(xform[0]*x + xform[1]*y));
  1026. X              ly = refy + round(yscl*(xform[2]*x + xform[3]*y));
  1027. X              draphy(lx,ly);
  1028. X            }
  1029. X            if (uline) {
  1030. X              x = xorg;
  1031. X              y = yorg + (-5+ydisp)*scale;
  1032. X              lx = refx + round(xscl*(xform[0]*x + xform[1]*y));
  1033. X              ly = refy + round(yscl*(xform[2]*x + xform[3]*y));
  1034. X              movphy(lx,ly);
  1035. X              x = xorg + width*scale;
  1036. X              lx = refx + round(xscl*(xform[0]*x + xform[1]*y));
  1037. X              ly = refy + round(yscl*(xform[2]*x + xform[3]*y));
  1038. X              draphy(lx,ly);
  1039. X            }
  1040. X            xorg = xorg + width*scale;
  1041. X          }
  1042. X        }
  1043. X      }
  1044. X      snms(style);
  1045. X}
  1046. X
  1047. SHAR_EOF
  1048. echo "extracting plstrl.c"
  1049. sed 's/^X//' << \SHAR_EOF > plstrl.c
  1050. X/* Computes the length of a string in mm, including escape sequences  */
  1051. X
  1052. X#include "plplot.h"
  1053. X#include <math.h>
  1054. X
  1055. Xfloat plstrl(string)
  1056. Xchar *string;
  1057. X{
  1058. X      int symbol[256];
  1059. X      short int xygrid[300];
  1060. X      int ch, i, length, level;
  1061. X      float width, xorg, dscale, scale, def, ht;
  1062. X      float xscl, xoff, yscl, yoff;
  1063. X
  1064. X      width = 0.0;
  1065. X      gchr(&def,&ht);
  1066. X      dscale = 0.05*ht;
  1067. X      scale = dscale;
  1068. X      gmp(&xscl,&xoff,&yscl,&yoff);
  1069. X
  1070. X      pldeco(symbol,&length,string);
  1071. X      xorg = 0.0;
  1072. X      level = 0;
  1073. X 
  1074. X      for (i=0; i<length; i++) {
  1075. X        ch = symbol[i];
  1076. X        if (ch == -1) {
  1077. X          level = level + 1;
  1078. X          scale = dscale * pow(0.75,(double)abs(level));
  1079. X        }
  1080. X        else if (ch == -2) {  
  1081. X          level = level - 1;
  1082. X          scale = dscale * pow(0.75,(double)abs(level));
  1083. X        }
  1084. X        else if (ch == -3) 
  1085. X          xorg = xorg - width * scale;
  1086. X        else if (ch == -4 || ch == -5) 
  1087. X          ;
  1088. X        else {
  1089. X          if (plcvec(ch,xygrid)) {
  1090. X            width = xygrid[4] - xygrid[3];
  1091. X            xorg = xorg + width*scale;
  1092. X          }
  1093. X        }
  1094. X      }
  1095. X      return(xorg);
  1096. X}
  1097. SHAR_EOF
  1098. echo "extracting plstyl.c"
  1099. sed 's/^X//' << \SHAR_EOF > plstyl.c
  1100. X/* Set up a new line style of "nels" elements, with mark and space */
  1101. X/* lengths given by arrays "mk" and "sp". */
  1102. X
  1103. X#include "plplot.h"
  1104. X#include "declare.h"
  1105. X
  1106. Xvoid plstyl(nels,mk,sp)
  1107. Xint nels,mk[],sp[];
  1108. X{
  1109. X    int i;
  1110. X
  1111. X    if ((nels < 0) || (nels > 10)) {
  1112. X      fatal("Broken lines cannot have <0 or >10 elements");
  1113. X    }
  1114. X
  1115. X    nms = nels;
  1116. X    for (i=0; i<nels; i++) {
  1117. X        mark[i] = mk[i];
  1118. X        space[i] = sp[i];
  1119. X        if ((mk[i] < 0) || (sp[i] < 0))
  1120. X            fatal("Mark and space lengths must be > 0 in PLSTYL");
  1121. X    }
  1122. X
  1123. X    curel = 0;
  1124. X    pendn = 1;
  1125. X    timecnt = 0;
  1126. X    alarm = mark[curel];
  1127. X}
  1128. X
  1129. X/* Updates line style variables, called whenever alarm goes off */
  1130. X
  1131. Xvoid plupd()
  1132. X{
  1133. X    while ( timecnt >= alarm ) {
  1134. X        if (pendn != 0) {
  1135. X            pendn = 0;
  1136. X            timecnt = timecnt - alarm;
  1137. X            alarm = space[curel];
  1138. X        }
  1139. X        else {
  1140. X            pendn = 1;
  1141. X            timecnt = timecnt - alarm;
  1142. X            curel = curel + 1;
  1143. X            if (curel >= nms) curel = 0;
  1144. X            alarm = mark[curel];
  1145. X        }
  1146. X    }
  1147. X}
  1148. X
  1149. X
  1150. SHAR_EOF
  1151. echo "extracting plsvpa.c"
  1152. sed 's/^X//' << \SHAR_EOF > plsvpa.c
  1153. X/* Sets the edges of the viewport to the specified absolute          */
  1154. X/* coordinates (mm), measured with respect to the current subpage    */
  1155. X/* boundaries                                                        */
  1156. X
  1157. X#include "plplot.h"
  1158. X
  1159. Xvoid plsvpa(xmin,xmax,ymin,ymax)
  1160. Xfloat xmin, xmax, ymin, ymax;
  1161. X{
  1162. X
  1163. X    int nx, ny, cs;
  1164. X    float sxmin, symin;
  1165. X    float spdxmi, spdxma, spdymi, spdyma;
  1166. X    float vpdxmi, vpdxma, vpdymi, vpdyma;
  1167. X
  1168. X    int level;
  1169. X
  1170. X    glev(&level);
  1171. X    if (level<1) fatal("Please call PLSTAR before calling PLSVPA.");
  1172. X    if((xmin>=xmax)||(ymin>=ymax)||(xmin<0.)||(ymin<0.))
  1173. X        fatal("Invalid limits in PLSVPA.");
  1174. X
  1175. X    gsub(&nx,&ny,&cs);
  1176. X    if ((cs<=0) || (cs>(nx*ny)))
  1177. X        fatal("Please call PLADV or PLENV to go to a subpage.");
  1178. X
  1179. X    gspd(&spdxmi,&spdxma,&spdymi,&spdyma);
  1180. X    sxmin = dcmmx(spdxmi);
  1181. X    symin = dcmmy(spdymi);
  1182. X
  1183. X    vpdxmi = mmdcx(sxmin+xmin);
  1184. X    vpdxma = mmdcx(sxmin+xmax);
  1185. X    vpdymi = mmdcy(symin+ymin);
  1186. X    vpdyma = mmdcy(symin+ymax);
  1187. X    
  1188. X    svpd(vpdxmi,vpdxma,vpdymi,vpdyma);
  1189. X    svpp(dcpcx(vpdxmi),dcpcx(vpdxma),dcpcy(vpdymi),dcpcy(vpdyma));
  1190. X    sclp(dcpcx(vpdxmi),dcpcx(vpdxma),dcpcy(vpdymi),dcpcy(vpdyma));
  1191. X    slev(2);
  1192. X}
  1193. X
  1194. SHAR_EOF
  1195. echo "extracting plsym.c"
  1196. sed 's/^X//' << \SHAR_EOF > plsym.c
  1197. X/* Plots single precision array y against x for n points using */
  1198. X/* Hershey symbol "code" */
  1199. X
  1200. X#include "plplot.h"
  1201. X
  1202. Xvoid plsym(n,x,y,code)
  1203. Xint n, code;
  1204. Xfloat x[],y[];
  1205. X{
  1206. X      int i;
  1207. X
  1208. X      int level;
  1209. X      glev(&level);
  1210. X      if (level < 3) fatal("Please set up window before calling PLSYM.");
  1211. X      if (code < 0) fatal("Invalid code in PLSYM.");
  1212. X
  1213. X      for (i=0; i<n; i++) 
  1214. X        plsym1(x[i],y[i],code);
  1215. X}
  1216. SHAR_EOF
  1217. echo "extracting plsym1.c"
  1218. sed 's/^X//' << \SHAR_EOF > plsym1.c
  1219. X#include "plplot.h"
  1220. X
  1221. Xvoid plsym1(x,y,code)
  1222. Xfloat x,y;
  1223. Xint code;
  1224. X{
  1225. X      plhrsh(code,wcpcx(x),wcpcy(y));
  1226. X}
  1227. SHAR_EOF
  1228. echo "extracting plt3zz.c"
  1229. sed 's/^X//' << \SHAR_EOF > plt3zz.c
  1230. X/* Draws the next zig-zag line for a 3-d plot. The data is stored in */
  1231. X/* array z(*,ly) as a function of x() and y(). The subarray */
  1232. X/* z(1:nx,1:ny) is plotted out, starting at index (xstar0,ystar0). */
  1233. X/* Depending on the state of "flg0", the sequence of data points */
  1234. X/* sent to plnxtv is altered so as to allow cross-hatch plotting, */
  1235. X/* or plotting parallel to either the x-axis or the y-axis. */
  1236. X
  1237. X#include "plplot.h"
  1238. X
  1239. Xvoid plt3zz(xstar0,ystar0,dx,dy,flg0,init,x,y,z,ly,nx,ny,u,v)
  1240. Xint xstar0, ystar0, dx, dy, flg0, ly, nx, ny, init;
  1241. Xfloat x[], y[], *z;
  1242. Xint u[], v[];
  1243. X{
  1244. X      int flag;
  1245. X      int n;
  1246. X      int xstart, ystart;
  1247. X
  1248. X      n = 0;
  1249. X      xstart = xstar0;
  1250. X      ystart = ystar0;
  1251. X      flag = flg0;
  1252. X      
  1253. Xlab1:
  1254. X      if (1 <= xstart && xstart <= nx && 1 <= ystart && ystart <= ny) {
  1255. X        u[n] = wcpcx(w3wcx(x[xstart-1],y[ystart-1],
  1256. X                      *(z+(xstart-1)*ly+(ystart-1))));
  1257. X        v[n] = wcpcy(w3wcy(x[xstart-1],y[ystart-1],
  1258. X                      *(z+(xstart-1)*ly+(ystart-1))));
  1259. X        if (flag == -3) {
  1260. X          ystart = ystart + dy;
  1261. X          flag = -flag;
  1262. X        }
  1263. X        else if (flag == -2) 
  1264. X          ystart = ystart + dy;
  1265. X        else if (flag == -1) {
  1266. X          ystart = ystart + dy;
  1267. X          flag = 1;
  1268. X        }
  1269. X        else if (flag == 1)
  1270. X          xstart = xstart + dx;
  1271. X        else if (flag == 2)  {
  1272. X          xstart = xstart + dx;
  1273. X          flag = -2;
  1274. X        }
  1275. X        else if (flag == 3) {
  1276. X          xstart = xstart + dx;
  1277. X          flag = -flag;
  1278. X        }
  1279. X        n = n+1;
  1280. X        goto lab1;
  1281. X      }
  1282. X
  1283. X      if (flag == 1 || flag == -2) {
  1284. X        if (flag == 1) {
  1285. X          xstart = xstart - dx;
  1286. X          ystart = ystart + dy;
  1287. X        }
  1288. X        else if (flag == -2) {
  1289. X          ystart = ystart - dy;
  1290. X          xstart = xstart + dx;
  1291. X        }
  1292. X
  1293. X        if (1 <= xstart && xstart <= nx  && 1 <= ystart && ystart <= ny) {
  1294. X          u[n] = wcpcx(w3wcx(x[xstart-1],y[ystart-1],
  1295. X                       *(z+(xstart-1)*ly+(ystart-1))));
  1296. X          v[n] = wcpcy(w3wcy(x[xstart-1],y[ystart-1],
  1297. X                       *(z+(xstart-1)*ly+(ystart-1))));
  1298. X          n = n+1;
  1299. X        }
  1300. X
  1301. X      }        
  1302. X      plnxtv(u,v,n,init);
  1303. X}
  1304. SHAR_EOF
  1305. echo "extracting pltext.c"
  1306. sed 's/^X//' << \SHAR_EOF > pltext.c
  1307. X/* Switches back to text mode */
  1308. X
  1309. X#include "plplot.h"
  1310. X
  1311. Xvoid pltext()
  1312. X{
  1313. X      int dev,term,gra,level;
  1314. X
  1315. X      glev(&level);
  1316. X      if (level < 1) fatal("Please call PLSTAR before calling PLTEXT.");
  1317. X
  1318. X      gdev(&dev,&term,&gra);
  1319. X      if (term != 0) beepw();
  1320. X      grtext();
  1321. X}
  1322. SHAR_EOF
  1323. echo "extracting plvpor.c"
  1324. sed 's/^X//' << \SHAR_EOF > plvpor.c
  1325. X/* Sets the edges of the viewport to the specified normalized subpage */
  1326. X/* coordinates */
  1327. X
  1328. X#include "plplot.h"
  1329. X
  1330. Xvoid plvpor(xmin, xmax, ymin, ymax)
  1331. Xfloat xmin, xmax, ymin, ymax;
  1332. X{
  1333. X    float spdxmi, spdxma, spdymi, spdyma;
  1334. X    float vpdxmi, vpdxma, vpdymi, vpdyma;
  1335. X    int vppxmi, vppxma, vppymi, vppyma;
  1336. X    
  1337. X    int nx, ny, cs;
  1338. X
  1339. X    int level;
  1340. X
  1341. X    glev(&level);
  1342. X    if (level < 1) fatal("Please call PLSTAR before calling PLVPOR.");
  1343. X    if((xmin>=xmax)||(ymin>=ymax)||(xmin<0.)||
  1344. X       (ymin<0.)||(xmax>1.)||(ymax>1.))
  1345. X        fatal("Invalid limits in PLSVPA.");
  1346. X
  1347. X    gsub(&nx,&ny,&cs);
  1348. X    if ((cs<=0) || (cs>(nx*ny)))
  1349. X        fatal("Please call PLADV or PLENV to go to a subpage.");
  1350. X    gspd(&spdxmi,&spdxma,&spdymi,&spdyma);
  1351. X    vpdxmi = spdxmi + (spdxma - spdxmi) * xmin;
  1352. X    vpdxma = spdxmi + (spdxma - spdxmi) * xmax;
  1353. X    vpdymi = spdymi + (spdyma - spdymi) * ymin;
  1354. X    vpdyma = spdymi + (spdyma - spdymi) * ymax;
  1355. X    svpd(vpdxmi,vpdxma,vpdymi,vpdyma);
  1356. X
  1357. X    vppxmi = dcpcx(vpdxmi);
  1358. X    vppxma = dcpcx(vpdxma);
  1359. X    vppymi = dcpcy(vpdymi);
  1360. X    vppyma = dcpcy(vpdyma);
  1361. X    svpp(vppxmi,vppxma,vppymi,vppyma);
  1362. X    sclp(vppxmi,vppxma,vppymi,vppyma);
  1363. X    slev(2);
  1364. X}
  1365. SHAR_EOF
  1366. echo "extracting plvsta.c"
  1367. sed 's/^X//' << \SHAR_EOF > plvsta.c
  1368. X/* Defines a "standard" viewport with seven character heights for   */
  1369. X/* the left margin and four character heights everywhere else       */
  1370. X
  1371. X#include "plplot.h"
  1372. X                                                                   
  1373. Xvoid plvsta()
  1374. X{
  1375. X    float xmin, xmax, ymin, ymax;
  1376. X    float chrdef, chrht, spdxmi, spdxma, spdymi, spdyma;
  1377. X
  1378. X    int level;
  1379. X
  1380. X    glev(&level);
  1381. X    if (level < 1) fatal("Please call PLSTAR before calling PLVSTA.");
  1382. X
  1383. X    gchr(&chrdef,&chrht);
  1384. X    gspd(&spdxmi,&spdxma,&spdymi,&spdyma);
  1385. X
  1386. X/*  Find out position of subpage boundaries in millimetres, reduce by */
  1387. X/*  the desired border, and convert back into normalized subpage */
  1388. X/*  coordinates */
  1389. X
  1390. X    xmin = dcscx(mmdcx(dcmmx(spdxmi) + 7 * chrht));
  1391. X    xmax = dcscx(mmdcx(dcmmx(spdxma) - 4 * chrht));
  1392. X    ymin = dcscy(mmdcy(dcmmy(spdymi) + 4 * chrht));
  1393. X    ymax = dcscy(mmdcy(dcmmy(spdyma) - 4 * chrht));
  1394. X
  1395. X    plvpor(xmin,xmax,ymin,ymax);
  1396. X}
  1397. SHAR_EOF
  1398. echo "extracting plw3d.c"
  1399. sed 's/^X//' << \SHAR_EOF > plw3d.c
  1400. X/* Set up a window for three-dimensional plotting. The data are mapped */
  1401. X/* into a box with world coordinate size "basex" by "basey" by "height", */
  1402. X/* with the base being symmetrically positioned about zero. Thus */
  1403. X/* the mapping between data 3-d and world 3-d coordinates is given by: */
  1404. X
  1405. X/*   x = xmin   =>   wx = -0.5*basex */
  1406. X/*   x = xmax   =>   wx =  0.5*basex */
  1407. X/*   y = ymin   =>   wy = -0.5*basey */
  1408. X/*   y = ymax   =>   wy =  0.5*basey */
  1409. X/*   z = zmin   =>   wz =  0.0 */
  1410. X/*   z = zmax   =>   wz =  height */
  1411. X
  1412. X/* The world coordinate box is then viewed from position "alt"-"az", */
  1413. X/* measured in degrees. For proper operation, 0 <= alt <= 90 degrees, */
  1414. X/* but az can be any value. */
  1415. X
  1416. X#include "plplot.h"
  1417. X#include <math.h>
  1418. X
  1419. X#define  dtr   0.01745329252
  1420. X
  1421. Xvoid plw3d(basex,basey,height,xmin0,xmax0,ymin0,ymax0,zmin0,zmax0,alt,az)
  1422. Xfloat basex, basey, height, xmin0, xmax0, ymin0, ymax0, zmin0, zmax0;
  1423. Xfloat alt, az;
  1424. X{
  1425. X      float xmin, xmax, ymin, ymax, zmin, zmax, d;
  1426. X      float cx, cy, saz, caz, salt, calt, zscale;
  1427. X
  1428. X      int level;
  1429. X      glev(&level);
  1430. X      if (level < 3) fatal("Please set up 2-d window before calling PLW3D.");
  1431. X      if (basex <= 0.0 || basey <= 0.0 || height <= 0.0)
  1432. X              fatal("Invalid world coordinate boxsize in PLW3D.");
  1433. X      if (xmin0 == xmax0 || ymin0 == ymax0 || zmin0 == zmax0)
  1434. X              fatal("Invalid axis range in PLW3D.");
  1435. X      if (alt<0.0 || alt>90.0)
  1436. X              fatal("Altitude must be between 0 and 90 degrees in PLW3D.");
  1437. X
  1438. X      d = 1.0e-5*(xmax0-xmin0);
  1439. X      xmax = xmax0 + d;
  1440. X      xmin = xmin0 - d;
  1441. X      d = 1.0e-5*(ymax0-ymin0);
  1442. X      ymax = ymax0 + d;
  1443. X      ymin = ymin0 - d;
  1444. X      d = 1.0e-5*(zmax0-zmin0);
  1445. X      zmax = zmax0 + d;
  1446. X      zmin = zmin0 - d;
  1447. X      cx = basex/(xmax-xmin);
  1448. X      cy = basey/(ymax-ymin);
  1449. X      zscale = height/(zmax-zmin);
  1450. X      saz = sin(dtr*az);
  1451. X      caz = cos(dtr*az);
  1452. X      salt = sin(dtr*alt);
  1453. X      calt = cos(dtr*alt);
  1454. X      
  1455. X      sdom(xmin,xmax,ymin,ymax);
  1456. X      srange(zscale,zmin,zmax);
  1457. X      sbase(basex,basey,0.5*(xmin+xmax),0.5*(ymin+ymax));
  1458. X
  1459. X      sw3wc(cx*caz,-cy*saz,cx*saz*salt,cy*caz*salt,zscale*calt);
  1460. X}
  1461. X
  1462. SHAR_EOF
  1463. echo "extracting plwind.c"
  1464. sed 's/^X//' << \SHAR_EOF > plwind.c
  1465. X#include "plplot.h"
  1466. X
  1467. Xvoid plwind(xmin,xmax,ymin,ymax)
  1468. Xfloat xmin, xmax, ymin, ymax;
  1469. X{
  1470. X    int vppxmi, vppxma, vppymi, vppyma;
  1471. X    float dx, dy;
  1472. X    float vpwxmi, vpwxma, vpwymi, vpwyma;
  1473. X    float vpxmi, vpxma, vpymi, vpyma;
  1474. X    float wpxscl, wpxoff, wpyscl, wpyoff;
  1475. X    float wmxscl, wmxoff, wmyscl, wmyoff;
  1476. X
  1477. X    int level;
  1478. X
  1479. X    glev(&level);
  1480. X    if (level<2) fatal("Please set up viewport before calling PLWIND.");
  1481. X
  1482. X    gvpp(&vppxmi,&vppxma,&vppymi,&vppyma);
  1483. X    gvpd(&vpxmi,&vpxma,&vpymi,&vpyma);
  1484. X
  1485. X    dx = (xmax-xmin) * 1.0e-5;
  1486. X    dy = (ymax-ymin) * 1.0e-5;
  1487. X
  1488. X    if ((xmin == xmax) || (ymin == ymax))
  1489. X        fatal("Invalid window limits in PLWIND.");
  1490. X   
  1491. X/* The true plot window is made slightly larger than requested so that */
  1492. X/* the end limits will be on the graph  */
  1493. X 
  1494. X    svpw(xmin-dx,xmax+dx,ymin-dy,ymax+dy);
  1495. X    gvpw(&vpwxmi,&vpwxma,&vpwymi,&vpwyma);
  1496. X
  1497. X/* Compute the scaling between coordinate systems */
  1498. X
  1499. X    dx = vpwxma - vpwxmi;
  1500. X    dy = vpwyma - vpwymi;
  1501. X 
  1502. X    wpxscl  = (vppxma - vppxmi) / dx;
  1503. X    wpxoff  = (xmax * vppxmi - xmin * vppxma) / dx;
  1504. X    wpyscl  = (vppyma - vppymi) / dy;
  1505. X    wpyoff  = (ymax * vppymi - ymin * vppyma) / dy;
  1506. X    swp(wpxscl,wpxoff,wpyscl,wpyoff);
  1507. X
  1508. X    vpxmi = dcmmx(vpxmi);
  1509. X    vpxma = dcmmx(vpxma);
  1510. X    vpymi = dcmmy(vpymi);
  1511. X    vpyma = dcmmy(vpyma);
  1512. X    wmxscl = (vpxma - vpxmi) / dx;
  1513. X    wmxoff = (xmax * vpxmi - xmin * vpxma) / dx;
  1514. X    wmyscl = (vpyma - vpymi) / dy;
  1515. X    wmyoff = (ymax * vpymi - ymin * vpyma) / dy;
  1516. X    swm(wmxscl,wmxoff,wmyscl,wmyoff);
  1517. X
  1518. X    slev(3);
  1519. X}SHAR_EOF
  1520. echo "extracting plxtik.c"
  1521. sed 's/^X//' << \SHAR_EOF > plxtik.c
  1522. X#include "plplot.h"
  1523. X
  1524. Xvoid plxtik(x,y,below,above)
  1525. Xint x, y, below, above;
  1526. X{      
  1527. X      draphy(x,y);
  1528. X      if (below != 0) draphy(x,y-below);
  1529. X      if (above != 0) draphy(x,y+above);
  1530. X      draphy(x,y);
  1531. X}
  1532. SHAR_EOF
  1533. echo "extracting plxybx.c"
  1534. sed 's/^X//' << \SHAR_EOF > plxybx.c
  1535. X/* This draws a sloping line from (wx1,wy1) to (wx2,wy2)             */
  1536. X/*  which represents an axis of a 3-d graph with data values from    */
  1537. X/*  "vmin" to "vmax". Depending on "opt", vertical ticks and/or      */
  1538. X/*  subticks are placed on the line at major tick interval "tick"    */
  1539. X/*  with "nsub" subticks between major ticks. If "tick" and/or       */
  1540. X/*  "nsub" is zero, automatic tick positions are computed            */
  1541. X
  1542. X/* B: Draw box boundary                                              */
  1543. X/* I: Inverts tick marks (i.e. drawn downwards)                      */
  1544. X/* L: Logarithmic axes, major ticks at decades, minor ticks at units */
  1545. X/* N: Write numeric label                                            */
  1546. X/* T: Draw major tick marks                                          */
  1547. X/* S: Draw minor tick marks                                          */
  1548. X/* U: Write label on line                                            */
  1549. X
  1550. X#include "plplot.h"
  1551. X#include <stdio.h>
  1552. X#include <math.h>
  1553. X
  1554. X#define  betw(c,a,b)  ((a <= c && c <= b) || (b <= c && c <= a))
  1555. X
  1556. Xstatic float xlog[8] = 
  1557. X  {0.301030,0.477121,0.602060,0.698970,0.778151,0.845098,0.903090,0.954243};
  1558. X
  1559. Xvoid plxybx(opt,label,wx1,wy1,wx2,wy2,vmin,vmax,tick,nsub,nolast)
  1560. Xchar *opt, *label;
  1561. Xfloat wx1, wy1, wx2, wy2, vmin, vmax, tick;
  1562. Xint nsub, nolast;
  1563. X{
  1564. X      char string[40];
  1565. X      int lb,li,ll,ln,ls,lt,lu;
  1566. X      int major, minor, mode, prec;
  1567. X      int i, i1, i2, i3, i4;
  1568. X      int nsub1;
  1569. X      float xpmm, ypmm, defmaj, defmin, htmaj, htmin, tick1;
  1570. X      float pos, tn, tp, temp;
  1571. X      float dwx, dwy, lambda;
  1572. X
  1573. X      dwx = wx2 - wx1;
  1574. X      dwy = wy2 - wy1;
  1575. X
  1576. X/* Tick and subtick sizes in device coords */
  1577. X
  1578. X      gpixmm(&xpmm,&ypmm);
  1579. X      gmaj(&defmaj,&htmaj);
  1580. X      gmin(&defmin,&htmin);
  1581. X      
  1582. X      major=max(round(htmaj*ypmm),1);
  1583. X      minor=max(round(htmin*ypmm),1);
  1584. X
  1585. X      tick1=tick;
  1586. X      nsub1=nsub;
  1587. X
  1588. X      lb=strpos(opt,'B')!=-1||strpos(opt,'b')!=-1;
  1589. X      li=strpos(opt,'I')!=-1||strpos(opt,'i')!=-1;
  1590. X      ll=strpos(opt,'L')!=-1||strpos(opt,'l')!=-1;
  1591. X      ln=strpos(opt,'N')!=-1||strpos(opt,'n')!=-1;
  1592. X      ls=strpos(opt,'S')!=-1||strpos(opt,'s')!=-1;
  1593. X      lt=strpos(opt,'T')!=-1||strpos(opt,'t')!=-1;
  1594. X      lu=strpos(opt,'U')!=-1||strpos(opt,'u')!=-1;
  1595. X
  1596. X      if (lu) plxytx(wx1,wy1,wx2,wy2,3.2,0.5,0.5,label);
  1597. X      if (!lb) return;
  1598. X   
  1599. X      if (ll) tick1 = 1.0;
  1600. X      if (lt) pldtik(vmin,vmax,&tick1,&nsub1,&mode,&prec);
  1601. X
  1602. X      if (li) {
  1603. X        i1 = minor;
  1604. X        i2 = 0;
  1605. X        i3 = major;
  1606. X        i4 = 0;
  1607. X      }
  1608. X      else  {
  1609. X        i1 = 0;
  1610. X        i2 = minor;
  1611. X        i3 = 0;
  1612. X        i4 = major;
  1613. X      }  
  1614. X
  1615. X/* Draw the line */
  1616. X
  1617. X      movwor(wx1,wy1);
  1618. X      if (lt) {
  1619. X        tp=tick1*floor(vmin/tick1);
  1620. Xlab2:
  1621. X        tn=tp+tick1;
  1622. X        if (ls) {
  1623. X          if (ll) {
  1624. X            for (i=0; i<=7; i++)  {
  1625. X              temp=tp+xlog[i];
  1626. X              if (betw(temp,vmin,vmax)) {
  1627. X                lambda = (temp-vmin)/(vmax-vmin);
  1628. X                plxtik(wcpcx(wx1+lambda*dwx),wcpcy(wy1+lambda*dwy),i1,i2);
  1629. X              }
  1630. X            }
  1631. X          }
  1632. X          else  {
  1633. X            for(i=1; i <= nsub1-1; i++)  {
  1634. X              temp=tp+i*(tn-tp)/nsub1;
  1635. X              if (betw(temp,vmin,vmax)) {
  1636. X                lambda = (temp-vmin)/(vmax-vmin);
  1637. X                plxtik(wcpcx(wx1+lambda*dwx),wcpcy(wy1+lambda*dwy),i1,i2);
  1638. X              }
  1639. X            }
  1640. X          }
  1641. X        }
  1642. X        temp=tn;
  1643. X        if (betw(temp,vmin,vmax)) {
  1644. X          lambda = (temp-vmin)/(vmax-vmin);
  1645. X          plxtik(wcpcx(wx1+lambda*dwx),wcpcy(wy1+lambda*dwy),i3,i4);
  1646. X          tp=tn;
  1647. X          goto lab2;
  1648. X        }
  1649. X      }
  1650. X
  1651. X      drawor(wx2,wy2);
  1652. X
  1653. X/* Label the line */
  1654. X
  1655. X      if (ln && lt) {
  1656. X        tp=tick1*floor(vmin/tick1);
  1657. Xlab82:
  1658. X        tn=tp+tick1;
  1659. X        if (nolast && !betw(tn+tick1,vmin,vmax)) return;
  1660. X        if (betw(tn,vmin,vmax)) {
  1661. X          if (!ll) 
  1662. X            plform(tn,mode,prec,string);
  1663. X          else 
  1664. X            sprintf(string,"10\\u%-d",round(tn));
  1665. X          pos=(tn-vmin)/(vmax-vmin);
  1666. X          if (ln) plxytx(wx1,wy1,wx2,wy2,1.5,pos,0.5,string);
  1667. X          tp=tn;
  1668. X          goto lab82;
  1669. X        }
  1670. X      }
  1671. X}
  1672. SHAR_EOF
  1673. echo "extracting plxytx.c"
  1674. sed 's/^X//' << \SHAR_EOF > plxytx.c
  1675. X/* Prints out text along a sloping axis joining world coordinates */
  1676. X/* (wx1,wy1) to (wx2,wy2). Parameters are as for plmtext          */
  1677. X
  1678. X#include "plplot.h"
  1679. X#include <math.h>
  1680. X
  1681. Xvoid plxytx(wx1,wy1,wx2,wy2,disp,pos,just,text)
  1682. Xfloat wx1,wy1,wx2,wy2,disp,pos,just;
  1683. Xchar *text;
  1684. X{      
  1685. X      int refx, refy;
  1686. X      float shift, cc, ss, def, ht;
  1687. X      float xform[4], diag;
  1688. X      float xscl, xoff, yscl, yoff, wx, wy;
  1689. X   
  1690. X      gchr(&def,&ht);
  1691. X      gwm(&xscl,&xoff,&yscl,&yoff);
  1692. X      cc = xscl * (wx2-wx1);
  1693. X      ss = yscl * (wy2-wy1);
  1694. X      diag = sqrt(cc*cc + ss*ss);
  1695. X      cc = cc/diag;
  1696. X      ss = ss/diag;
  1697. X
  1698. X      xform[0] = cc;
  1699. X      xform[1] = 0.0;
  1700. X      xform[2] = ss;
  1701. X      xform[3] = 1.0;
  1702. X
  1703. X      shift = 0.0;
  1704. X      if (just != 0.0) shift = plstrl(text) * just;
  1705. X      wx = wx1 + pos * (wx2 - wx1);
  1706. X      wy = wy1 + pos * (wy2 - wy1);
  1707. X      
  1708. X      refx = mmpcx(wcmmx(wx) - shift * cc);
  1709. X      refy = mmpcy(wcmmy(wy) - shift * ss - disp * ht);
  1710. X      plstr(0,xform,refx,refy,text);
  1711. X}
  1712. SHAR_EOF
  1713. echo "extracting plytik.c"
  1714. sed 's/^X//' << \SHAR_EOF > plytik.c
  1715. X#include "plplot.h"
  1716. X
  1717. Xvoid plytik(x,y,left,right)
  1718. Xint x, y, left, right;
  1719. X{      
  1720. X      draphy(x,y);
  1721. X      if (left != 0) draphy(x-left,y);
  1722. X      if (right != 0) draphy(x+right,y);
  1723. X      draphy(x,y);
  1724. X}
  1725. SHAR_EOF
  1726. echo "extracting plzbx.c"
  1727. sed 's/^X//' << \SHAR_EOF > plzbx.c
  1728. X/* This draws a vertical line from (wx,wy1) to (wx,wy2)           */
  1729. X/*  which represents the vertical axis of a 3-d graph with data   */
  1730. X/*  values from "vmin" to "vmax". Depending on "opt", ticks and/or*/
  1731. X/*  subticks are placed on the line at major tick interval "tick" */
  1732. X/*  with "nsub" subticks between major ticks. If "tick" and/or    */
  1733. X/*  "nsub" is zero, automatic tick positions are computed         */
  1734. X
  1735. X/* B: Draws left-hand axis*/
  1736. X/* C: Draws right-hand axis*/
  1737. X/* I: Inverts tick marks (i.e. drawn to the left)  */
  1738. X/* L: Logarithmic axes, major ticks at decades, minor ticks at units*/
  1739. X/* M: Write numeric label on right axis*/
  1740. X/* N: Write numeric label on left axis*/
  1741. X/* S: Draw minor tick marks  */
  1742. X/* T: Draw major tick marks  */
  1743. X/* U: Writes left-hand label*/
  1744. X/* V: Writes right-hand label*/
  1745. X
  1746. X#include "plplot.h"
  1747. X#include <stdio.h>
  1748. X#include <math.h>
  1749. X
  1750. X#define betw(c,a,b) ((a <= c && c <= b) || (b <= c && c <= a))
  1751. X
  1752. Xstatic float xlog[8] =
  1753. X  {0.301030,0.477121,0.602060,0.698970,0.778151,0.845098,
  1754. X   0.903090,0.954243};
  1755. X
  1756. Xvoid plzbx(opt,label,right,dx,dy,wx,wy1,wy2,vmin,vmax,tick,nsub)
  1757. Xchar *opt, *label;
  1758. Xfloat dx, dy, wx, wy1, wy2, vmin, vmax, tick;
  1759. Xint nsub, right;
  1760. X{
  1761. X      char string[40];
  1762. X      int lb,lc,li,ll,lm,ln,ls,lt,lu,lv;
  1763. X      int i, mode, prec;
  1764. X      int nsub1;
  1765. X      float xpmm, ypmm, defmaj, defmin, tick1;
  1766. X      float pos, tn, tp, temp;
  1767. X      float dwy, lambda, diag, major, minor, xmajor, xminor;
  1768. X      float ymajor, yminor, dxm, dym, xscl, xoff, yscl, yoff;
  1769. X               
  1770. X      dwy = wy2 - wy1;
  1771. X
  1772. X/* Tick and subtick sizes in device coords */
  1773. X
  1774. X      gpixmm(&xpmm,&ypmm);
  1775. X      gmaj(&defmaj,&major);
  1776. X      gmin(&defmin,&minor);
  1777. X      
  1778. X      tick1=tick;
  1779. X      nsub1=nsub;
  1780. X
  1781. X      lb=strpos(opt,'B') != -1 || strpos(opt,'b') != -1;
  1782. X      lc=strpos(opt,'C') != -1 || strpos(opt,'c') != -1;
  1783. X      li=strpos(opt,'I') != -1 || strpos(opt,'i') != -1;
  1784. X      ll=strpos(opt,'L') != -1 || strpos(opt,'l') != -1;
  1785. X      lm=strpos(opt,'M') != -1 || strpos(opt,'m') != -1;
  1786. X      ln=strpos(opt,'N') != -1 || strpos(opt,'n') != -1;
  1787. X      ls=strpos(opt,'S') != -1 || strpos(opt,'s') != -1;
  1788. X      lt=strpos(opt,'T') != -1 || strpos(opt,'t') != -1;
  1789. X      lu=strpos(opt,'U') != -1 || strpos(opt,'u') != -1;
  1790. X      lv=strpos(opt,'V') != -1 || strpos(opt,'v') != -1;
  1791. X
  1792. X      if (lu && !right) plztx("h",dx,dy,wx,wy1,wy2,5.0,0.5,0.5,label);
  1793. X      if (lv && right) plztx("h",dx,dy,wx,wy1,wy2,-5.0,0.5,0.5,label);
  1794. X
  1795. X      if (right && !lc) return;
  1796. X      if (!right && !lb) return;
  1797. X
  1798. X      if (ll) tick1 = 1.0;
  1799. X      if (lt) pldtik(vmin,vmax,&tick1,&nsub1,&mode,&prec);
  1800. X
  1801. X      if ( (li && !right) || (!li && right) ) {
  1802. X        minor = -minor;
  1803. X        major = -major;
  1804. X      }  
  1805. X
  1806. X      gwm(&xscl,&xoff,&yscl,&yoff);
  1807. X      dxm = dx * xscl;
  1808. X      dym = dy * yscl;
  1809. X      diag = sqrt(dxm*dxm + dym*dym);
  1810. X
  1811. X      xminor = minor * dxm/diag;
  1812. X      xmajor = major * dxm/diag;
  1813. X      yminor = minor * dym/diag;
  1814. X      ymajor = major * dym/diag;
  1815. X
  1816. X/* Draw the line */
  1817. X
  1818. X      movwor(wx,wy1);
  1819. X      if (lt) {
  1820. X        tp=tick1*floor(vmin/tick1);
  1821. Xlab2:
  1822. X        tn=tp+tick1;
  1823. X        if (ls) {
  1824. X          if (ll) {
  1825. X            for (i=0; i <= 7; i++) {
  1826. X              temp=tp+xlog[i];
  1827. X              if (betw(temp,vmin,vmax)) {
  1828. X                lambda = (temp-vmin)/(vmax-vmin);
  1829. X                plstik(wcmmx(wx),wcmmy(wy1+lambda*dwy),xminor,yminor);
  1830. X              }
  1831. X            }
  1832. X          }
  1833. X          else  {
  1834. X            for (i=1; i<= nsub1-1; i++)  {
  1835. X              temp=tp+i*(tn-tp)/nsub1;
  1836. X              if (betw(temp,vmin,vmax)) {
  1837. X                lambda = (temp-vmin)/(vmax-vmin);
  1838. X                plstik(wcmmx(wx),wcmmy(wy1+lambda*dwy),xminor,yminor);
  1839. X              }
  1840. X            }
  1841. X          }
  1842. X        }
  1843. X        temp=tn;
  1844. X        if (betw(temp,vmin,vmax)) {
  1845. X          lambda = (temp-vmin)/(vmax-vmin);
  1846. X          plstik(wcmmx(wx),wcmmy(wy1+lambda*dwy),xmajor,ymajor);
  1847. X          tp=tn;
  1848. X          goto lab2;
  1849. X        }
  1850. X      }
  1851. X
  1852. X      drawor(wx,wy2);
  1853. X
  1854. X/* Label the line */
  1855. X
  1856. X      if (ln && lt) {
  1857. X        tp=tick1*floor(vmin/tick1);
  1858. Xlab82:
  1859. X        tn=tp+tick1;
  1860. X        if (betw(tn,vmin,vmax)) {
  1861. X          if (!ll) 
  1862. X            plform(tn,mode,prec,string);
  1863. X          else
  1864. X            sprintf(string,"10\\u%d",round(tn));
  1865. X          pos=(tn-vmin)/(vmax-vmin);
  1866. X          if (ln && !right) plztx("v",dx,dy,wx,wy1,wy2,0.5,pos,1.0,string);
  1867. X          if (lm && right) plztx("v",dx,dy,wx,wy1,wy2,-0.5,pos,0.0,string);
  1868. X          tp=tn;
  1869. X          goto lab82;
  1870. X        }
  1871. X      }
  1872. X}
  1873. SHAR_EOF
  1874. echo "extracting plztx.c"
  1875. sed 's/^X//' << \SHAR_EOF > plztx.c
  1876. X/* Prints out text along a vertical axis for a 3d plot joining         */
  1877. X/*  world coordinates (wx,wy1) to (wx,wy2).                            */
  1878. X
  1879. X#include "plplot.h"
  1880. X#include <math.h>
  1881. X
  1882. Xvoid plztx(opt,dx,dy,wx,wy1,wy2,disp,pos,just,text)
  1883. Xfloat dx,dy,wx,wy1,wy2,disp,pos,just;
  1884. Xchar *opt, *text;
  1885. X{      
  1886. X      int refx, refy;
  1887. X      int vert;
  1888. X      float shift, cc, ss, def, ht;
  1889. X      float xform[4], diag;
  1890. X      float xscl, xoff, yscl, yoff, wy;
  1891. X   
  1892. X      gchr(&def,&ht);
  1893. X      gwm(&xscl,&xoff,&yscl,&yoff);
  1894. X      cc = xscl * dx;
  1895. X      ss = yscl * dy;
  1896. X      diag = sqrt(cc*cc + ss*ss);
  1897. X      cc = cc/diag;
  1898. X      ss = ss/diag;
  1899. X      gmp(&xscl,&xoff,&yscl,&yoff);
  1900. X
  1901. X      shift = 0.0;
  1902. X      if (just != 0.0) shift = plstrl(text) * just;
  1903. X      wy = wy1 + pos * (wy2 - wy1);
  1904. X      
  1905. X      if (strpos(opt,'V') != -1 || strpos(opt,'v') != -1) {
  1906. X        vert = 0;
  1907. X        refx = mmpcx(wcmmx(wx) - (disp * ht + shift) * cc);
  1908. X        refy = mmpcy(wcmmy(wy) - (disp * ht + shift) * ss);
  1909. X      }
  1910. X      else if (strpos(opt,'H') != -1 || strpos(opt,'h') != -1) {
  1911. X        vert = 1;
  1912. X        refy = wcpcy(wy) - yscl*(disp*ht*ss+shift);
  1913. X        refx = mmpcx(wcmmx(wx) - disp*ht*cc);
  1914. X      }
  1915. X      if (vert) {
  1916. X        xform[0] = 0.0;
  1917. X        xform[1] = -cc;
  1918. X        xform[2] = 1.0;
  1919. X        xform[3] = -ss;
  1920. X      }
  1921. X      else {
  1922. X        xform[0] = cc;
  1923. X        xform[1] = 0.0;
  1924. X        xform[2] = ss;
  1925. X        xform[3] = 1.0;
  1926. X      }
  1927. X      plstr(0,xform,refx,refy,text);
  1928. X}
  1929. SHAR_EOF
  1930. echo "extracting round.c"
  1931. sed 's/^X//' << \SHAR_EOF > round.c
  1932. X/* round rounds a floating point value to an integer value. */
  1933. X
  1934. X#include "plplot.h"
  1935. X#include <math.h>
  1936. X
  1937. Xint round(flt)
  1938. Xfloat flt;
  1939. X{
  1940. X    double mant, frac;
  1941. X
  1942. X    frac = modf(flt,&mant);
  1943. X    if( fabs(frac) < .5 )
  1944. X        return((int)mant);
  1945. X    else if (frac > 0)
  1946. X        return((int)(++mant));
  1947. X    else 
  1948. X        return((int)(--mant));
  1949. X}
  1950. SHAR_EOF
  1951. echo "extracting scratch"
  1952. sed 's/^X//' << \SHAR_EOF > scratch
  1953. X; I had problems with the LMKFILE when I wanted to remake the library
  1954. X; from scratch.  It barfed if I tried to pass to many source files to
  1955. X; the compiler.  Normally you shouldn't need to execute this script.
  1956. X; If you've only changed a few routines use LMK instead.  But in
  1957. X; case of disaster try this.  After you start it, take a break and
  1958. X; go get a pizza. No, wait, sorry, that was a flashback to my IBM
  1959. X; PC days.  Pop open a new window and do something else :-):-)
  1960. Xdelete lib/plplot.lib      ; delete old library
  1961. Xcopy nil: lib/plplot.lib   ; create an empty new one
  1962. Xtouch src/plabv.c src/pladv.c src/plbeg.c src/plbin.c src/plbox.c
  1963. Xtouch src/plccal.c src/plclr.c src/plcntr.c src/plcol.c src/plcont.c
  1964. Xtouch src/plcvec.c src/pldeco.c src/pldtik.c src/plend.c src/plenv.c
  1965. Xlmk
  1966. Xtouch src/plerrx.c src/plerry.c src/plerx1.c src/plery1.c src/plfont.c
  1967. Xtouch src/plform.c src/plgra.c src/plgspa.c src/plhist.c src/plhrsh.c
  1968. Xtouch src/pljoin.c src/pllab.c src/pllclp.c src/plline.c src/plmtex.c
  1969. Xlmk
  1970. Xtouch src/plnxtv.c src/plpoi1.c src/plpoin.c src/plptex.c src/plr135.c
  1971. Xtouch src/plr45.c src/plschr.c src/plsmaj.c src/plsmin.c src/plssym.c
  1972. Xtouch src/plstar.c src/plstik.c src/plstr.c src/plstrl.c src/plstyl.c
  1973. Xlmk
  1974. Xtouch src/plsvpa.c src/plsym.c src/plsym1.c src/pltext.c src/plvpor.c
  1975. Xtouch src/plvsta.c src/plwind.c src/plxtik.c src/plxybx.c src/plxytx.c
  1976. Xtouch src/plytik.c src/plzbx.c src/plztx.c src/pl3cut.c src/plbox3.c
  1977. Xlmk
  1978. Xtouch src/plgrid3.c src/plot3d.c src/plside3.c src/plt3zz.c src/plw3d.c
  1979. Xtouch src/define.c src/fatal.c src/fcnvrt.c src/genlin.c src/global.c
  1980. Xtouch src/icnvrt.c src/movphy.c src/movwor.c src/round.c src/setphy.c
  1981. Xlmk
  1982. Xtouch src/setpxl.c src/setsub.c src/stindex.c src/strpos.c src/xform.c
  1983. Xtouch src/impress.c src/laserjetii.c src/tektronix.c src/Amiga.c
  1984. Xtouch src/font01.c src/font02.c src/font03.c src/font04.c src/font05.c
  1985. Xlmk
  1986. Xtouch src/font06.c src/font07.c src/font08.c src/font09.c src/font10.c
  1987. Xtouch src/font11.c
  1988. Xlmk
  1989. SHAR_EOF
  1990. echo "extracting setphy.c"
  1991. sed 's/^X//' << \SHAR_EOF > setphy.c
  1992. X/* Sets up physical limits of plotting device and the mapping between */
  1993. X/* normalized device coordinates and physical coordinates */
  1994. X
  1995. X#include "plplot.h"
  1996. X
  1997. Xvoid setphy(xmin,xmax,ymin,ymax)
  1998. Xint xmin,xmax,ymin,ymax;
  1999. X{
  2000. X    float xpmm, ypmm, mpxscl, mpyscl;
  2001. X
  2002. X    sphy(xmin,xmax,ymin,ymax);
  2003. X    sdp((double)(xmax-xmin),(double)(xmin),(double)(ymax-ymin),
  2004. X         (double)(ymin));
  2005. X
  2006. X    gpixmm(&xpmm,&ypmm);
  2007. X    mpxscl = xpmm;
  2008. X    if (xmax <= xmin) mpxscl = -xpmm;
  2009. X    mpyscl = ypmm;
  2010. X    if (ymax <= ymin) mpyscl = -ypmm;
  2011. X    smp(mpxscl,(double)(xmin), mpyscl,(double)(ymin));
  2012. X}
  2013. X
  2014. SHAR_EOF
  2015. echo "extracting setpxl.c"
  2016. sed 's/^X//' << \SHAR_EOF > setpxl.c
  2017. X/* Sets up pixel size from the number of pixels/mm in each direction */
  2018. X
  2019. X#include "plplot.h"
  2020. X#include "declare.h"
  2021. X
  2022. Xvoid setpxl(xpmm0,ypmm0)
  2023. Xfloat xpmm0,ypmm0;
  2024. X{
  2025. X    xpmm = xpmm0;
  2026. X    ypmm = ypmm0;
  2027. X    umx  = 1000.0/xpmm;
  2028. X    umy  = 1000.0/ypmm;
  2029. X}
  2030. SHAR_EOF
  2031. echo "extracting setsub.c"
  2032. sed 's/^X//' << \SHAR_EOF > setsub.c
  2033. X/* Sets up the subpage boundaries according to the current subpage  */
  2034. X/* selected */
  2035. X
  2036. X#include "plplot.h"
  2037. X
  2038. Xvoid setsub()
  2039. X{
  2040. X      int ix, iy;
  2041. X      int nsubx, nsuby, cursub;
  2042. X      float spdxmi, spdxma, spdymi, spdyma;
  2043. X      int sppxmi, sppxma, sppymi, sppyma;
  2044. X
  2045. X      gsub(&nsubx,&nsuby,&cursub);
  2046. X      ix = (cursub-1)%nsubx;
  2047. X      iy = nsuby - (cursub-1)/nsubx;
  2048. X
  2049. X      spdxmi = (float)(ix)/(float)(nsubx);
  2050. X      spdxma = (float)(ix+1)/(float)(nsubx);
  2051. X      spdymi = (float)(iy-1)/(float)(nsuby);
  2052. X      spdyma = (float)(iy)/(float)(nsuby);
  2053. X      sspd(spdxmi,spdxma,spdymi,spdyma);
  2054. X
  2055. X      sppxmi = dcpcx(spdxmi);
  2056. X      sppxma = dcpcx(spdxma);
  2057. X      sppymi = dcpcy(spdymi);
  2058. X      sppyma = dcpcy(spdyma);
  2059. X      sspp(sppxmi,sppxma,sppymi,sppyma);
  2060. X
  2061. X      sclp(sppxmi,sppxma,sppymi,sppyma);
  2062. X      
  2063. X}
  2064. SHAR_EOF
  2065. echo "extracting stindex.c"
  2066. sed 's/^X//' << \SHAR_EOF > stindex.c
  2067. X#include "plplot.h"
  2068. X
  2069. Xint stindex(str1,str2)
  2070. Xchar *str1,*str2;
  2071. X{
  2072. X    int base;
  2073. X    int str1ind;
  2074. X    int str2ind;
  2075. X
  2076. X    for(base=0; *(str1+base)!='\0'; base++) {
  2077. X        for(str1ind=base, str2ind=0; *(str2+str2ind)!='\0' &&
  2078. X            *(str2+str2ind) == *(str1+str1ind); str1ind++, str2ind++)
  2079. X            ;   /* no body */
  2080. X
  2081. X        if(*(str2+str2ind) == '\0')
  2082. X            return(base);
  2083. X    }
  2084. X    return(-1);    /* search failed */
  2085. X}
  2086. SHAR_EOF
  2087. echo "extracting strpos.c"
  2088. sed 's/^X//' << \SHAR_EOF > strpos.c
  2089. X/* Searches string str for first occurence of character chr.  If found */
  2090. X/* the position of the character in the string is returned (the first  */
  2091. X/* character has position 0).  If the character is not found a -1 is   */
  2092. X/* returned. */
  2093. X
  2094. X#include "plplot.h"
  2095. X#include <stdio.h>     /* Needed to define NULL */
  2096. X#include <string.h>
  2097. X
  2098. Xint strpos(str,chr)
  2099. Xchar *str,chr;
  2100. X{
  2101. X    char *temp;
  2102. X
  2103. X    if ( (temp = strchr(str,chr)) != NULL)
  2104. X        return(temp - str);
  2105. X    else
  2106. X        return(-1);
  2107. X}
  2108. SHAR_EOF
  2109. echo "extracting tektronix.c"
  2110. sed 's/^X//' << \SHAR_EOF > tektronix.c
  2111. X/* This file contains the tektronix dependent routines for use with plplot. */
  2112. X
  2113. X/* Define graphics control characters. */
  2114. X#define BS    8
  2115. X#define HT    9
  2116. X#define LF   10
  2117. X#define VT   11
  2118. X#define FF   12
  2119. X#define CR   13
  2120. X#define CAN  24
  2121. X#define EM   25
  2122. X#define ESC  27
  2123. X#define FS   28
  2124. X#define GS   29
  2125. X#define US   31
  2126. X
  2127. X#include <stdio.h>
  2128. X#include "plplot.h"
  2129. X
  2130. Xstatic FILE *OutFile;
  2131. Xstatic int FirstClear=1;
  2132. X
  2133. X/* Open file. */
  2134. Xvoid tekini()
  2135. X{
  2136. X      char FileName[80];
  2137. X
  2138. X      printf("Enter file to receive tektronix graphics commands. ");
  2139. X      scanf("%s",FileName);
  2140. X
  2141. X      if ((OutFile = fopen(FileName,"w")) == NULL)  {
  2142. X          printf("Error opening %s \n",FileName);
  2143. X          exit(1);
  2144. X      }
  2145. X}
  2146. X
  2147. X/* Sets the tektronix to text mode */
  2148. Xvoid tektex()
  2149. X{
  2150. X    fprintf(OutFile,"%c",US);
  2151. X}
  2152. X
  2153. X/* Sets the tektronix to graphics mode */
  2154. Xvoid tekgra()
  2155. X{
  2156. X    /* Nothing has to be done here */
  2157. X}
  2158. X
  2159. X/* Clears the tektronix screen */
  2160. Xvoid tekclr()
  2161. X{
  2162. X      if(FirstClear) 
  2163. X        FirstClear = 0;
  2164. X      else
  2165. X        fprintf(OutFile,"%c%c",ESC,FF);
  2166. X}
  2167. X
  2168. X/* Change color */
  2169. Xvoid tekcol(colour)
  2170. Xint colour;
  2171. X{
  2172. X}
  2173. X
  2174. X/* Draws a line in the current colour from (x1,y1) to (x2,y2) */
  2175. Xvoid teklin(x1,y1,x2,y2)
  2176. Xint x1,y1,x2,y2;
  2177. X{
  2178. X    int hy,ly,hx,lx;
  2179. X
  2180. X    fprintf(OutFile,"%c",GS);
  2181. X    hy = y1/32 + 32;
  2182. X    ly = y1 - (y1/32)*32 + 96;
  2183. X    hx = x1/32 + 32;
  2184. X    lx = x1 - (x1/32)*32 + 64;
  2185. X    fprintf(OutFile,"%c%c%c%c",hy,ly,hx,lx);
  2186. X    hy = y2/32 + 32;
  2187. X    ly = y2 - (y2/32)*32 + 96;
  2188. X    hx = x2/32 + 32;
  2189. X    lx = x2 - (x2/32)*32 + 64;
  2190. X    fprintf(OutFile,"%c%c%c%c",hy,ly,hx,lx);
  2191. X}
  2192. X
  2193. X/* Close file */
  2194. Xvoid tektid()
  2195. X{
  2196. X   fclose(OutFile);
  2197. X}
  2198. X
  2199. SHAR_EOF
  2200. echo "extracting xform.c"
  2201. sed 's/^X//' << \SHAR_EOF > xform.c
  2202. X#include "plplot.h"
  2203. X
  2204. Xvoid xform(x,y,tx,ty)
  2205. Xfloat x, y, *tx, *ty;
  2206. X{
  2207. X      extern float tr[];
  2208. X
  2209. X      *tx = tr[0]*x + tr[1]*y + tr[2];
  2210. X      *ty = tr[3]*x + tr[4]*y + tr[5];
  2211. X}
  2212. X
  2213. SHAR_EOF
  2214. echo "End of archive 7 (of 7)"
  2215. # if you want to concatenate archives, remove anything after this line
  2216. exit
  2217.